// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: dc2.proto

#ifndef PROTOBUF_dc2_2eproto__INCLUDED
#define PROTOBUF_dc2_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 3004000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 3004000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
namespace dc2 {
class ChannelInfoReq;
class ChannelInfoReqDefaultTypeInternal;
extern ChannelInfoReqDefaultTypeInternal _ChannelInfoReq_default_instance_;
class ChannelsReq;
class ChannelsReqDefaultTypeInternal;
extern ChannelsReqDefaultTypeInternal _ChannelsReq_default_instance_;
class ChatChannel;
class ChatChannelDefaultTypeInternal;
extern ChatChannelDefaultTypeInternal _ChatChannel_default_instance_;
class ChatMessage;
class ChatMessageDefaultTypeInternal;
extern ChatMessageDefaultTypeInternal _ChatMessage_default_instance_;
class Empty;
class EmptyDefaultTypeInternal;
extern EmptyDefaultTypeInternal _Empty_default_instance_;
class SIDMsg;
class SIDMsgDefaultTypeInternal;
extern SIDMsgDefaultTypeInternal _SIDMsg_default_instance_;
class SetChannelOptionsReq;
class SetChannelOptionsReqDefaultTypeInternal;
extern SetChannelOptionsReqDefaultTypeInternal _SetChannelOptionsReq_default_instance_;
class SoftwareInfo;
class SoftwareInfoDefaultTypeInternal;
extern SoftwareInfoDefaultTypeInternal _SoftwareInfo_default_instance_;
class Time;
class TimeDefaultTypeInternal;
extern TimeDefaultTypeInternal _Time_default_instance_;
class User;
class UserDefaultTypeInternal;
extern UserDefaultTypeInternal _User_default_instance_;
class UserDetails;
class UserDetailsDefaultTypeInternal;
extern UserDetailsDefaultTypeInternal _UserDetails_default_instance_;
class UsersReq;
class UsersReqDefaultTypeInternal;
extern UsersReqDefaultTypeInternal _UsersReq_default_instance_;
class Version;
class VersionDefaultTypeInternal;
extern VersionDefaultTypeInternal _Version_default_instance_;
}  // namespace dc2

namespace dc2 {

namespace protobuf_dc2_2eproto {
// Internal implementation detail -- do not call these.
struct TableStruct {
  static const ::google::protobuf::internal::ParseTableField entries[];
  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
  static const ::google::protobuf::internal::ParseTable schema[];
  static const ::google::protobuf::uint32 offsets[];
  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
  static const ::google::protobuf::internal::SerializationTable serialization_table[];
  static void InitDefaultsImpl();
};
void AddDescriptors();
void InitDefaults();
}  // namespace protobuf_dc2_2eproto

enum SetChannelOptionsReq_State {
  SetChannelOptionsReq_State_JOIN = 0,
  SetChannelOptionsReq_State_LEAVE = 1,
  SetChannelOptionsReq_State_SetChannelOptionsReq_State_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  SetChannelOptionsReq_State_SetChannelOptionsReq_State_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool SetChannelOptionsReq_State_IsValid(int value);
const SetChannelOptionsReq_State SetChannelOptionsReq_State_State_MIN = SetChannelOptionsReq_State_JOIN;
const SetChannelOptionsReq_State SetChannelOptionsReq_State_State_MAX = SetChannelOptionsReq_State_LEAVE;
const int SetChannelOptionsReq_State_State_ARRAYSIZE = SetChannelOptionsReq_State_State_MAX + 1;

const ::google::protobuf::EnumDescriptor* SetChannelOptionsReq_State_descriptor();
inline const ::std::string& SetChannelOptionsReq_State_Name(SetChannelOptionsReq_State value) {
  return ::google::protobuf::internal::NameOfEnum(
    SetChannelOptionsReq_State_descriptor(), value);
}
inline bool SetChannelOptionsReq_State_Parse(
    const ::std::string& name, SetChannelOptionsReq_State* value) {
  return ::google::protobuf::internal::ParseNamedEnum<SetChannelOptionsReq_State>(
    SetChannelOptionsReq_State_descriptor(), name, value);
}
enum User_Kind {
  User_Kind_HUMAN = 0,
  User_Kind_BOT = 1,
  User_Kind_User_Kind_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  User_Kind_User_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool User_Kind_IsValid(int value);
const User_Kind User_Kind_Kind_MIN = User_Kind_HUMAN;
const User_Kind User_Kind_Kind_MAX = User_Kind_BOT;
const int User_Kind_Kind_ARRAYSIZE = User_Kind_Kind_MAX + 1;

const ::google::protobuf::EnumDescriptor* User_Kind_descriptor();
inline const ::std::string& User_Kind_Name(User_Kind value) {
  return ::google::protobuf::internal::NameOfEnum(
    User_Kind_descriptor(), value);
}
inline bool User_Kind_Parse(
    const ::std::string& name, User_Kind* value) {
  return ::google::protobuf::internal::ParseNamedEnum<User_Kind>(
    User_Kind_descriptor(), name, value);
}
enum User_Status {
  User_Status_OFFLINE = 0,
  User_Status_ONLINE = 1,
  User_Status_AWAY = 2,
  User_Status_User_Status_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  User_Status_User_Status_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool User_Status_IsValid(int value);
const User_Status User_Status_Status_MIN = User_Status_OFFLINE;
const User_Status User_Status_Status_MAX = User_Status_AWAY;
const int User_Status_Status_ARRAYSIZE = User_Status_Status_MAX + 1;

const ::google::protobuf::EnumDescriptor* User_Status_descriptor();
inline const ::std::string& User_Status_Name(User_Status value) {
  return ::google::protobuf::internal::NameOfEnum(
    User_Status_descriptor(), value);
}
inline bool User_Status_Parse(
    const ::std::string& name, User_Status* value) {
  return ::google::protobuf::internal::ParseNamedEnum<User_Status>(
    User_Status_descriptor(), name, value);
}
enum User_Role {
  User_Role_NONE = 0,
  User_Role_UNREGISTERED = 1,
  User_Role_REGISTERED = 2,
  User_Role_OPERATOR = 3,
  User_Role_ADMIN = 4,
  User_Role_User_Role_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
  User_Role_User_Role_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
};
bool User_Role_IsValid(int value);
const User_Role User_Role_Role_MIN = User_Role_NONE;
const User_Role User_Role_Role_MAX = User_Role_ADMIN;
const int User_Role_Role_ARRAYSIZE = User_Role_Role_MAX + 1;

const ::google::protobuf::EnumDescriptor* User_Role_descriptor();
inline const ::std::string& User_Role_Name(User_Role value) {
  return ::google::protobuf::internal::NameOfEnum(
    User_Role_descriptor(), value);
}
inline bool User_Role_Parse(
    const ::std::string& name, User_Role* value) {
  return ::google::protobuf::internal::ParseNamedEnum<User_Role>(
    User_Role_descriptor(), name, value);
}
// ===================================================================

class Empty : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.Empty) */ {
 public:
  Empty();
  virtual ~Empty();

  Empty(const Empty& from);

  inline Empty& operator=(const Empty& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Empty(Empty&& from) noexcept
    : Empty() {
    *this = ::std::move(from);
  }

  inline Empty& operator=(Empty&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Empty& default_instance();

  static inline const Empty* internal_default_instance() {
    return reinterpret_cast<const Empty*>(
               &_Empty_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    0;

  void Swap(Empty* other);
  friend void swap(Empty& a, Empty& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline Empty* New() const PROTOBUF_FINAL { return New(NULL); }

  Empty* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Empty& from);
  void MergeFrom(const Empty& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(Empty* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // @@protoc_insertion_point(class_scope:dc2.Empty)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SIDMsg : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.SIDMsg) */ {
 public:
  SIDMsg();
  virtual ~SIDMsg();

  SIDMsg(const SIDMsg& from);

  inline SIDMsg& operator=(const SIDMsg& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SIDMsg(SIDMsg&& from) noexcept
    : SIDMsg() {
    *this = ::std::move(from);
  }

  inline SIDMsg& operator=(SIDMsg&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SIDMsg& default_instance();

  static inline const SIDMsg* internal_default_instance() {
    return reinterpret_cast<const SIDMsg*>(
               &_SIDMsg_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    1;

  void Swap(SIDMsg* other);
  friend void swap(SIDMsg& a, SIDMsg& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SIDMsg* New() const PROTOBUF_FINAL { return New(NULL); }

  SIDMsg* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const SIDMsg& from);
  void MergeFrom(const SIDMsg& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(SIDMsg* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 sid = 1;
  void clear_sid();
  static const int kSidFieldNumber = 1;
  ::google::protobuf::int64 sid() const;
  void set_sid(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:dc2.SIDMsg)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 sid_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Time : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.Time) */ {
 public:
  Time();
  virtual ~Time();

  Time(const Time& from);

  inline Time& operator=(const Time& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Time(Time&& from) noexcept
    : Time() {
    *this = ::std::move(from);
  }

  inline Time& operator=(Time&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Time& default_instance();

  static inline const Time* internal_default_instance() {
    return reinterpret_cast<const Time*>(
               &_Time_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    2;

  void Swap(Time* other);
  friend void swap(Time& a, Time& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline Time* New() const PROTOBUF_FINAL { return New(NULL); }

  Time* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Time& from);
  void MergeFrom(const Time& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(Time* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 sec = 1;
  void clear_sec();
  static const int kSecFieldNumber = 1;
  ::google::protobuf::int64 sec() const;
  void set_sec(::google::protobuf::int64 value);

  // int64 nsec = 2;
  void clear_nsec();
  static const int kNsecFieldNumber = 2;
  ::google::protobuf::int64 nsec() const;
  void set_nsec(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:dc2.Time)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 sec_;
  ::google::protobuf::int64 nsec_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ChannelsReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.ChannelsReq) */ {
 public:
  ChannelsReq();
  virtual ~ChannelsReq();

  ChannelsReq(const ChannelsReq& from);

  inline ChannelsReq& operator=(const ChannelsReq& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ChannelsReq(ChannelsReq&& from) noexcept
    : ChannelsReq() {
    *this = ::std::move(from);
  }

  inline ChannelsReq& operator=(ChannelsReq&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ChannelsReq& default_instance();

  static inline const ChannelsReq* internal_default_instance() {
    return reinterpret_cast<const ChannelsReq*>(
               &_ChannelsReq_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    3;

  void Swap(ChannelsReq* other);
  friend void swap(ChannelsReq& a, ChannelsReq& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline ChannelsReq* New() const PROTOBUF_FINAL { return New(NULL); }

  ChannelsReq* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ChannelsReq& from);
  void MergeFrom(const ChannelsReq& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ChannelsReq* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 after_sid = 1;
  void clear_after_sid();
  static const int kAfterSidFieldNumber = 1;
  ::google::protobuf::int64 after_sid() const;
  void set_after_sid(::google::protobuf::int64 value);

  // int32 limit = 2;
  void clear_limit();
  static const int kLimitFieldNumber = 2;
  ::google::protobuf::int32 limit() const;
  void set_limit(::google::protobuf::int32 value);

  // bool watch = 3;
  void clear_watch();
  static const int kWatchFieldNumber = 3;
  bool watch() const;
  void set_watch(bool value);

  // @@protoc_insertion_point(class_scope:dc2.ChannelsReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 after_sid_;
  ::google::protobuf::int32 limit_;
  bool watch_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ChannelInfoReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.ChannelInfoReq) */ {
 public:
  ChannelInfoReq();
  virtual ~ChannelInfoReq();

  ChannelInfoReq(const ChannelInfoReq& from);

  inline ChannelInfoReq& operator=(const ChannelInfoReq& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ChannelInfoReq(ChannelInfoReq&& from) noexcept
    : ChannelInfoReq() {
    *this = ::std::move(from);
  }

  inline ChannelInfoReq& operator=(ChannelInfoReq&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ChannelInfoReq& default_instance();

  static inline const ChannelInfoReq* internal_default_instance() {
    return reinterpret_cast<const ChannelInfoReq*>(
               &_ChannelInfoReq_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    4;

  void Swap(ChannelInfoReq* other);
  friend void swap(ChannelInfoReq& a, ChannelInfoReq& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline ChannelInfoReq* New() const PROTOBUF_FINAL { return New(NULL); }

  ChannelInfoReq* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ChannelInfoReq& from);
  void MergeFrom(const ChannelInfoReq& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ChannelInfoReq* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string name = 2;
  void clear_name();
  static const int kNameFieldNumber = 2;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // int64 sid = 1;
  void clear_sid();
  static const int kSidFieldNumber = 1;
  ::google::protobuf::int64 sid() const;
  void set_sid(::google::protobuf::int64 value);

  // @@protoc_insertion_point(class_scope:dc2.ChannelInfoReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::int64 sid_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ChatChannel : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.ChatChannel) */ {
 public:
  ChatChannel();
  virtual ~ChatChannel();

  ChatChannel(const ChatChannel& from);

  inline ChatChannel& operator=(const ChatChannel& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ChatChannel(ChatChannel&& from) noexcept
    : ChatChannel() {
    *this = ::std::move(from);
  }

  inline ChatChannel& operator=(ChatChannel&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ChatChannel& default_instance();

  static inline const ChatChannel* internal_default_instance() {
    return reinterpret_cast<const ChatChannel*>(
               &_ChatChannel_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    5;

  void Swap(ChatChannel* other);
  friend void swap(ChatChannel& a, ChatChannel& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline ChatChannel* New() const PROTOBUF_FINAL { return New(NULL); }

  ChatChannel* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ChatChannel& from);
  void MergeFrom(const ChatChannel& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ChatChannel* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string name = 2;
  void clear_name();
  static const int kNameFieldNumber = 2;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // string desc = 3;
  void clear_desc();
  static const int kDescFieldNumber = 3;
  const ::std::string& desc() const;
  void set_desc(const ::std::string& value);
  #if LANG_CXX11
  void set_desc(::std::string&& value);
  #endif
  void set_desc(const char* value);
  void set_desc(const char* value, size_t size);
  ::std::string* mutable_desc();
  ::std::string* release_desc();
  void set_allocated_desc(::std::string* desc);

  // int64 sid = 1;
  void clear_sid();
  static const int kSidFieldNumber = 1;
  ::google::protobuf::int64 sid() const;
  void set_sid(::google::protobuf::int64 value);

  // bool removed = 4;
  void clear_removed();
  static const int kRemovedFieldNumber = 4;
  bool removed() const;
  void set_removed(bool value);

  // bool private = 5;
  void clear_private_();
  static const int kPrivateFieldNumber = 5;
  bool private_() const;
  void set_private_(bool value);

  // @@protoc_insertion_point(class_scope:dc2.ChatChannel)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::internal::ArenaStringPtr desc_;
  ::google::protobuf::int64 sid_;
  bool removed_;
  bool private__;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SetChannelOptionsReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.SetChannelOptionsReq) */ {
 public:
  SetChannelOptionsReq();
  virtual ~SetChannelOptionsReq();

  SetChannelOptionsReq(const SetChannelOptionsReq& from);

  inline SetChannelOptionsReq& operator=(const SetChannelOptionsReq& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SetChannelOptionsReq(SetChannelOptionsReq&& from) noexcept
    : SetChannelOptionsReq() {
    *this = ::std::move(from);
  }

  inline SetChannelOptionsReq& operator=(SetChannelOptionsReq&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SetChannelOptionsReq& default_instance();

  static inline const SetChannelOptionsReq* internal_default_instance() {
    return reinterpret_cast<const SetChannelOptionsReq*>(
               &_SetChannelOptionsReq_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    6;

  void Swap(SetChannelOptionsReq* other);
  friend void swap(SetChannelOptionsReq& a, SetChannelOptionsReq& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SetChannelOptionsReq* New() const PROTOBUF_FINAL { return New(NULL); }

  SetChannelOptionsReq* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const SetChannelOptionsReq& from);
  void MergeFrom(const SetChannelOptionsReq& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(SetChannelOptionsReq* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  typedef SetChannelOptionsReq_State State;
  static const State JOIN =
    SetChannelOptionsReq_State_JOIN;
  static const State LEAVE =
    SetChannelOptionsReq_State_LEAVE;
  static inline bool State_IsValid(int value) {
    return SetChannelOptionsReq_State_IsValid(value);
  }
  static const State State_MIN =
    SetChannelOptionsReq_State_State_MIN;
  static const State State_MAX =
    SetChannelOptionsReq_State_State_MAX;
  static const int State_ARRAYSIZE =
    SetChannelOptionsReq_State_State_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  State_descriptor() {
    return SetChannelOptionsReq_State_descriptor();
  }
  static inline const ::std::string& State_Name(State value) {
    return SetChannelOptionsReq_State_Name(value);
  }
  static inline bool State_Parse(const ::std::string& name,
      State* value) {
    return SetChannelOptionsReq_State_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // string name = 2;
  void clear_name();
  static const int kNameFieldNumber = 2;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // int64 sid = 1;
  void clear_sid();
  static const int kSidFieldNumber = 1;
  ::google::protobuf::int64 sid() const;
  void set_sid(::google::protobuf::int64 value);

  // .dc2.SetChannelOptionsReq.State state = 3;
  void clear_state();
  static const int kStateFieldNumber = 3;
  ::dc2::SetChannelOptionsReq_State state() const;
  void set_state(::dc2::SetChannelOptionsReq_State value);

  // @@protoc_insertion_point(class_scope:dc2.SetChannelOptionsReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::google::protobuf::int64 sid_;
  int state_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class ChatMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.ChatMessage) */ {
 public:
  ChatMessage();
  virtual ~ChatMessage();

  ChatMessage(const ChatMessage& from);

  inline ChatMessage& operator=(const ChatMessage& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  ChatMessage(ChatMessage&& from) noexcept
    : ChatMessage() {
    *this = ::std::move(from);
  }

  inline ChatMessage& operator=(ChatMessage&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const ChatMessage& default_instance();

  enum DestitationCase {
    kChannel = 4,
    kPmUser = 5,
    DESTITATION_NOT_SET = 0,
  };

  static inline const ChatMessage* internal_default_instance() {
    return reinterpret_cast<const ChatMessage*>(
               &_ChatMessage_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    7;

  void Swap(ChatMessage* other);
  friend void swap(ChatMessage& a, ChatMessage& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline ChatMessage* New() const PROTOBUF_FINAL { return New(NULL); }

  ChatMessage* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const ChatMessage& from);
  void MergeFrom(const ChatMessage& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(ChatMessage* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // repeated int64 mention = 8;
  int mention_size() const;
  void clear_mention();
  static const int kMentionFieldNumber = 8;
  ::google::protobuf::int64 mention(int index) const;
  void set_mention(int index, ::google::protobuf::int64 value);
  void add_mention(::google::protobuf::int64 value);
  const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      mention() const;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_mention();

  // string text = 1;
  void clear_text();
  static const int kTextFieldNumber = 1;
  const ::std::string& text() const;
  void set_text(const ::std::string& value);
  #if LANG_CXX11
  void set_text(::std::string&& value);
  #endif
  void set_text(const char* value);
  void set_text(const char* value, size_t size);
  ::std::string* mutable_text();
  ::std::string* release_text();
  void set_allocated_text(::std::string* text);

  // .dc2.Time ts = 2;
  bool has_ts() const;
  void clear_ts();
  static const int kTsFieldNumber = 2;
  const ::dc2::Time& ts() const;
  ::dc2::Time* mutable_ts();
  ::dc2::Time* release_ts();
  void set_allocated_ts(::dc2::Time* ts);

  // int64 author = 3;
  void clear_author();
  static const int kAuthorFieldNumber = 3;
  ::google::protobuf::int64 author() const;
  void set_author(::google::protobuf::int64 value);

  // bool me = 6;
  void clear_me();
  static const int kMeFieldNumber = 6;
  bool me() const;
  void set_me(bool value);

  // bool notify = 7;
  void clear_notify();
  static const int kNotifyFieldNumber = 7;
  bool notify() const;
  void set_notify(bool value);

  // int64 channel = 4;
  private:
  bool has_channel() const;
  public:
  void clear_channel();
  static const int kChannelFieldNumber = 4;
  ::google::protobuf::int64 channel() const;
  void set_channel(::google::protobuf::int64 value);

  // int64 pm_user = 5;
  private:
  bool has_pm_user() const;
  public:
  void clear_pm_user();
  static const int kPmUserFieldNumber = 5;
  ::google::protobuf::int64 pm_user() const;
  void set_pm_user(::google::protobuf::int64 value);

  DestitationCase destitation_case() const;
  // @@protoc_insertion_point(class_scope:dc2.ChatMessage)
 private:
  void set_has_channel();
  void set_has_pm_user();

  inline bool has_destitation() const;
  void clear_destitation();
  inline void clear_has_destitation();

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > mention_;
  mutable int _mention_cached_byte_size_;
  ::google::protobuf::internal::ArenaStringPtr text_;
  ::dc2::Time* ts_;
  ::google::protobuf::int64 author_;
  bool me_;
  bool notify_;
  union DestitationUnion {
    DestitationUnion() {}
    ::google::protobuf::int64 channel_;
    ::google::protobuf::int64 pm_user_;
  } destitation_;
  mutable int _cached_size_;
  ::google::protobuf::uint32 _oneof_case_[1];

  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class Version : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.Version) */ {
 public:
  Version();
  virtual ~Version();

  Version(const Version& from);

  inline Version& operator=(const Version& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  Version(Version&& from) noexcept
    : Version() {
    *this = ::std::move(from);
  }

  inline Version& operator=(Version&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const Version& default_instance();

  static inline const Version* internal_default_instance() {
    return reinterpret_cast<const Version*>(
               &_Version_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    8;

  void Swap(Version* other);
  friend void swap(Version& a, Version& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline Version* New() const PROTOBUF_FINAL { return New(NULL); }

  Version* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const Version& from);
  void MergeFrom(const Version& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(Version* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int32 major = 1;
  void clear_major();
  static const int kMajorFieldNumber = 1;
  ::google::protobuf::int32 major() const;
  void set_major(::google::protobuf::int32 value);

  // int32 minor = 2;
  void clear_minor();
  static const int kMinorFieldNumber = 2;
  ::google::protobuf::int32 minor() const;
  void set_minor(::google::protobuf::int32 value);

  // int32 patch = 3;
  void clear_patch();
  static const int kPatchFieldNumber = 3;
  ::google::protobuf::int32 patch() const;
  void set_patch(::google::protobuf::int32 value);

  // @@protoc_insertion_point(class_scope:dc2.Version)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int32 major_;
  ::google::protobuf::int32 minor_;
  ::google::protobuf::int32 patch_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class SoftwareInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.SoftwareInfo) */ {
 public:
  SoftwareInfo();
  virtual ~SoftwareInfo();

  SoftwareInfo(const SoftwareInfo& from);

  inline SoftwareInfo& operator=(const SoftwareInfo& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  SoftwareInfo(SoftwareInfo&& from) noexcept
    : SoftwareInfo() {
    *this = ::std::move(from);
  }

  inline SoftwareInfo& operator=(SoftwareInfo&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const SoftwareInfo& default_instance();

  static inline const SoftwareInfo* internal_default_instance() {
    return reinterpret_cast<const SoftwareInfo*>(
               &_SoftwareInfo_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    9;

  void Swap(SoftwareInfo* other);
  friend void swap(SoftwareInfo& a, SoftwareInfo& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline SoftwareInfo* New() const PROTOBUF_FINAL { return New(NULL); }

  SoftwareInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const SoftwareInfo& from);
  void MergeFrom(const SoftwareInfo& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(SoftwareInfo* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string name = 1;
  void clear_name();
  static const int kNameFieldNumber = 1;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // .dc2.Version version = 2;
  bool has_version() const;
  void clear_version();
  static const int kVersionFieldNumber = 2;
  const ::dc2::Version& version() const;
  ::dc2::Version* mutable_version();
  ::dc2::Version* release_version();
  void set_allocated_version(::dc2::Version* version);

  // @@protoc_insertion_point(class_scope:dc2.SoftwareInfo)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::dc2::Version* version_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class UserDetails : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.UserDetails) */ {
 public:
  UserDetails();
  virtual ~UserDetails();

  UserDetails(const UserDetails& from);

  inline UserDetails& operator=(const UserDetails& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  UserDetails(UserDetails&& from) noexcept
    : UserDetails() {
    *this = ::std::move(from);
  }

  inline UserDetails& operator=(UserDetails&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const UserDetails& default_instance();

  static inline const UserDetails* internal_default_instance() {
    return reinterpret_cast<const UserDetails*>(
               &_UserDetails_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    10;

  void Swap(UserDetails* other);
  friend void swap(UserDetails& a, UserDetails& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline UserDetails* New() const PROTOBUF_FINAL { return New(NULL); }

  UserDetails* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const UserDetails& from);
  void MergeFrom(const UserDetails& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(UserDetails* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // string real_name = 1;
  void clear_real_name();
  static const int kRealNameFieldNumber = 1;
  const ::std::string& real_name() const;
  void set_real_name(const ::std::string& value);
  #if LANG_CXX11
  void set_real_name(::std::string&& value);
  #endif
  void set_real_name(const char* value);
  void set_real_name(const char* value, size_t size);
  ::std::string* mutable_real_name();
  ::std::string* release_real_name();
  void set_allocated_real_name(::std::string* real_name);

  // string about = 2;
  void clear_about();
  static const int kAboutFieldNumber = 2;
  const ::std::string& about() const;
  void set_about(const ::std::string& value);
  #if LANG_CXX11
  void set_about(::std::string&& value);
  #endif
  void set_about(const char* value);
  void set_about(const char* value, size_t size);
  ::std::string* mutable_about();
  ::std::string* release_about();
  void set_allocated_about(::std::string* about);

  // string email = 3;
  void clear_email();
  static const int kEmailFieldNumber = 3;
  const ::std::string& email() const;
  void set_email(const ::std::string& value);
  #if LANG_CXX11
  void set_email(::std::string&& value);
  #endif
  void set_email(const char* value);
  void set_email(const char* value, size_t size);
  ::std::string* mutable_email();
  ::std::string* release_email();
  void set_allocated_email(::std::string* email);

  // @@protoc_insertion_point(class_scope:dc2.UserDetails)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr real_name_;
  ::google::protobuf::internal::ArenaStringPtr about_;
  ::google::protobuf::internal::ArenaStringPtr email_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class User : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.User) */ {
 public:
  User();
  virtual ~User();

  User(const User& from);

  inline User& operator=(const User& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  User(User&& from) noexcept
    : User() {
    *this = ::std::move(from);
  }

  inline User& operator=(User&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const User& default_instance();

  static inline const User* internal_default_instance() {
    return reinterpret_cast<const User*>(
               &_User_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    11;

  void Swap(User* other);
  friend void swap(User& a, User& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline User* New() const PROTOBUF_FINAL { return New(NULL); }

  User* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const User& from);
  void MergeFrom(const User& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(User* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  typedef User_Kind Kind;
  static const Kind HUMAN =
    User_Kind_HUMAN;
  static const Kind BOT =
    User_Kind_BOT;
  static inline bool Kind_IsValid(int value) {
    return User_Kind_IsValid(value);
  }
  static const Kind Kind_MIN =
    User_Kind_Kind_MIN;
  static const Kind Kind_MAX =
    User_Kind_Kind_MAX;
  static const int Kind_ARRAYSIZE =
    User_Kind_Kind_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Kind_descriptor() {
    return User_Kind_descriptor();
  }
  static inline const ::std::string& Kind_Name(Kind value) {
    return User_Kind_Name(value);
  }
  static inline bool Kind_Parse(const ::std::string& name,
      Kind* value) {
    return User_Kind_Parse(name, value);
  }

  typedef User_Status Status;
  static const Status OFFLINE =
    User_Status_OFFLINE;
  static const Status ONLINE =
    User_Status_ONLINE;
  static const Status AWAY =
    User_Status_AWAY;
  static inline bool Status_IsValid(int value) {
    return User_Status_IsValid(value);
  }
  static const Status Status_MIN =
    User_Status_Status_MIN;
  static const Status Status_MAX =
    User_Status_Status_MAX;
  static const int Status_ARRAYSIZE =
    User_Status_Status_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Status_descriptor() {
    return User_Status_descriptor();
  }
  static inline const ::std::string& Status_Name(Status value) {
    return User_Status_Name(value);
  }
  static inline bool Status_Parse(const ::std::string& name,
      Status* value) {
    return User_Status_Parse(name, value);
  }

  typedef User_Role Role;
  static const Role NONE =
    User_Role_NONE;
  static const Role UNREGISTERED =
    User_Role_UNREGISTERED;
  static const Role REGISTERED =
    User_Role_REGISTERED;
  static const Role OPERATOR =
    User_Role_OPERATOR;
  static const Role ADMIN =
    User_Role_ADMIN;
  static inline bool Role_IsValid(int value) {
    return User_Role_IsValid(value);
  }
  static const Role Role_MIN =
    User_Role_Role_MIN;
  static const Role Role_MAX =
    User_Role_Role_MAX;
  static const int Role_ARRAYSIZE =
    User_Role_Role_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Role_descriptor() {
    return User_Role_descriptor();
  }
  static inline const ::std::string& Role_Name(Role value) {
    return User_Role_Name(value);
  }
  static inline bool Role_Parse(const ::std::string& name,
      Role* value) {
    return User_Role_Parse(name, value);
  }

  // accessors -------------------------------------------------------

  // string name = 2;
  void clear_name();
  static const int kNameFieldNumber = 2;
  const ::std::string& name() const;
  void set_name(const ::std::string& value);
  #if LANG_CXX11
  void set_name(::std::string&& value);
  #endif
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  ::std::string* mutable_name();
  ::std::string* release_name();
  void set_allocated_name(::std::string* name);

  // .dc2.SoftwareInfo client = 6;
  bool has_client() const;
  void clear_client();
  static const int kClientFieldNumber = 6;
  const ::dc2::SoftwareInfo& client() const;
  ::dc2::SoftwareInfo* mutable_client();
  ::dc2::SoftwareInfo* release_client();
  void set_allocated_client(::dc2::SoftwareInfo* client);

  // .dc2.UserDetails details = 7;
  bool has_details() const;
  void clear_details();
  static const int kDetailsFieldNumber = 7;
  const ::dc2::UserDetails& details() const;
  ::dc2::UserDetails* mutable_details();
  ::dc2::UserDetails* release_details();
  void set_allocated_details(::dc2::UserDetails* details);

  // int64 sid = 1;
  void clear_sid();
  static const int kSidFieldNumber = 1;
  ::google::protobuf::int64 sid() const;
  void set_sid(::google::protobuf::int64 value);

  // .dc2.User.Kind kind = 3;
  void clear_kind();
  static const int kKindFieldNumber = 3;
  ::dc2::User_Kind kind() const;
  void set_kind(::dc2::User_Kind value);

  // .dc2.User.Status status = 4;
  void clear_status();
  static const int kStatusFieldNumber = 4;
  ::dc2::User_Status status() const;
  void set_status(::dc2::User_Status value);

  // .dc2.User.Role role = 5;
  void clear_role();
  static const int kRoleFieldNumber = 5;
  ::dc2::User_Role role() const;
  void set_role(::dc2::User_Role value);

  // @@protoc_insertion_point(class_scope:dc2.User)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::internal::ArenaStringPtr name_;
  ::dc2::SoftwareInfo* client_;
  ::dc2::UserDetails* details_;
  ::google::protobuf::int64 sid_;
  int kind_;
  int status_;
  int role_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// -------------------------------------------------------------------

class UsersReq : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:dc2.UsersReq) */ {
 public:
  UsersReq();
  virtual ~UsersReq();

  UsersReq(const UsersReq& from);

  inline UsersReq& operator=(const UsersReq& from) {
    CopyFrom(from);
    return *this;
  }
  #if LANG_CXX11
  UsersReq(UsersReq&& from) noexcept
    : UsersReq() {
    *this = ::std::move(from);
  }

  inline UsersReq& operator=(UsersReq&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }
  #endif
  static const ::google::protobuf::Descriptor* descriptor();
  static const UsersReq& default_instance();

  static inline const UsersReq* internal_default_instance() {
    return reinterpret_cast<const UsersReq*>(
               &_UsersReq_default_instance_);
  }
  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
    12;

  void Swap(UsersReq* other);
  friend void swap(UsersReq& a, UsersReq& b) {
    a.Swap(&b);
  }

  // implements Message ----------------------------------------------

  inline UsersReq* New() const PROTOBUF_FINAL { return New(NULL); }

  UsersReq* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
  void CopyFrom(const UsersReq& from);
  void MergeFrom(const UsersReq& from);
  void Clear() PROTOBUF_FINAL;
  bool IsInitialized() const PROTOBUF_FINAL;

  size_t ByteSizeLong() const PROTOBUF_FINAL;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const PROTOBUF_FINAL;
  void InternalSwap(UsersReq* other);
  private:
  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
    return NULL;
  }
  inline void* MaybeArenaPtr() const {
    return NULL;
  }
  public:

  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  // int64 channel = 1;
  void clear_channel();
  static const int kChannelFieldNumber = 1;
  ::google::protobuf::int64 channel() const;
  void set_channel(::google::protobuf::int64 value);

  // int64 after_sid = 2;
  void clear_after_sid();
  static const int kAfterSidFieldNumber = 2;
  ::google::protobuf::int64 after_sid() const;
  void set_after_sid(::google::protobuf::int64 value);

  // int32 limit = 3;
  void clear_limit();
  static const int kLimitFieldNumber = 3;
  ::google::protobuf::int32 limit() const;
  void set_limit(::google::protobuf::int32 value);

  // bool watch = 4;
  void clear_watch();
  static const int kWatchFieldNumber = 4;
  bool watch() const;
  void set_watch(bool value);

  // @@protoc_insertion_point(class_scope:dc2.UsersReq)
 private:

  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
  ::google::protobuf::int64 channel_;
  ::google::protobuf::int64 after_sid_;
  ::google::protobuf::int32 limit_;
  bool watch_;
  mutable int _cached_size_;
  friend struct protobuf_dc2_2eproto::TableStruct;
};
// ===================================================================


// ===================================================================

#if !PROTOBUF_INLINE_NOT_IN_HEADERS
#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// Empty

// -------------------------------------------------------------------

// SIDMsg

// int64 sid = 1;
inline void SIDMsg::clear_sid() {
  sid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 SIDMsg::sid() const {
  // @@protoc_insertion_point(field_get:dc2.SIDMsg.sid)
  return sid_;
}
inline void SIDMsg::set_sid(::google::protobuf::int64 value) {
  
  sid_ = value;
  // @@protoc_insertion_point(field_set:dc2.SIDMsg.sid)
}

// -------------------------------------------------------------------

// Time

// int64 sec = 1;
inline void Time::clear_sec() {
  sec_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 Time::sec() const {
  // @@protoc_insertion_point(field_get:dc2.Time.sec)
  return sec_;
}
inline void Time::set_sec(::google::protobuf::int64 value) {
  
  sec_ = value;
  // @@protoc_insertion_point(field_set:dc2.Time.sec)
}

// int64 nsec = 2;
inline void Time::clear_nsec() {
  nsec_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 Time::nsec() const {
  // @@protoc_insertion_point(field_get:dc2.Time.nsec)
  return nsec_;
}
inline void Time::set_nsec(::google::protobuf::int64 value) {
  
  nsec_ = value;
  // @@protoc_insertion_point(field_set:dc2.Time.nsec)
}

// -------------------------------------------------------------------

// ChannelsReq

// int64 after_sid = 1;
inline void ChannelsReq::clear_after_sid() {
  after_sid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 ChannelsReq::after_sid() const {
  // @@protoc_insertion_point(field_get:dc2.ChannelsReq.after_sid)
  return after_sid_;
}
inline void ChannelsReq::set_after_sid(::google::protobuf::int64 value) {
  
  after_sid_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChannelsReq.after_sid)
}

// int32 limit = 2;
inline void ChannelsReq::clear_limit() {
  limit_ = 0;
}
inline ::google::protobuf::int32 ChannelsReq::limit() const {
  // @@protoc_insertion_point(field_get:dc2.ChannelsReq.limit)
  return limit_;
}
inline void ChannelsReq::set_limit(::google::protobuf::int32 value) {
  
  limit_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChannelsReq.limit)
}

// bool watch = 3;
inline void ChannelsReq::clear_watch() {
  watch_ = false;
}
inline bool ChannelsReq::watch() const {
  // @@protoc_insertion_point(field_get:dc2.ChannelsReq.watch)
  return watch_;
}
inline void ChannelsReq::set_watch(bool value) {
  
  watch_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChannelsReq.watch)
}

// -------------------------------------------------------------------

// ChannelInfoReq

// int64 sid = 1;
inline void ChannelInfoReq::clear_sid() {
  sid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 ChannelInfoReq::sid() const {
  // @@protoc_insertion_point(field_get:dc2.ChannelInfoReq.sid)
  return sid_;
}
inline void ChannelInfoReq::set_sid(::google::protobuf::int64 value) {
  
  sid_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChannelInfoReq.sid)
}

// string name = 2;
inline void ChannelInfoReq::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChannelInfoReq::name() const {
  // @@protoc_insertion_point(field_get:dc2.ChannelInfoReq.name)
  return name_.GetNoArena();
}
inline void ChannelInfoReq::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.ChannelInfoReq.name)
}
#if LANG_CXX11
inline void ChannelInfoReq::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.ChannelInfoReq.name)
}
#endif
inline void ChannelInfoReq::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.ChannelInfoReq.name)
}
inline void ChannelInfoReq::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.ChannelInfoReq.name)
}
inline ::std::string* ChannelInfoReq::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:dc2.ChannelInfoReq.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChannelInfoReq::release_name() {
  // @@protoc_insertion_point(field_release:dc2.ChannelInfoReq.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChannelInfoReq::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:dc2.ChannelInfoReq.name)
}

// -------------------------------------------------------------------

// ChatChannel

// int64 sid = 1;
inline void ChatChannel::clear_sid() {
  sid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 ChatChannel::sid() const {
  // @@protoc_insertion_point(field_get:dc2.ChatChannel.sid)
  return sid_;
}
inline void ChatChannel::set_sid(::google::protobuf::int64 value) {
  
  sid_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChatChannel.sid)
}

// string name = 2;
inline void ChatChannel::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChatChannel::name() const {
  // @@protoc_insertion_point(field_get:dc2.ChatChannel.name)
  return name_.GetNoArena();
}
inline void ChatChannel::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.ChatChannel.name)
}
#if LANG_CXX11
inline void ChatChannel::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.ChatChannel.name)
}
#endif
inline void ChatChannel::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.ChatChannel.name)
}
inline void ChatChannel::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.ChatChannel.name)
}
inline ::std::string* ChatChannel::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:dc2.ChatChannel.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChatChannel::release_name() {
  // @@protoc_insertion_point(field_release:dc2.ChatChannel.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChatChannel::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:dc2.ChatChannel.name)
}

// string desc = 3;
inline void ChatChannel::clear_desc() {
  desc_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChatChannel::desc() const {
  // @@protoc_insertion_point(field_get:dc2.ChatChannel.desc)
  return desc_.GetNoArena();
}
inline void ChatChannel::set_desc(const ::std::string& value) {
  
  desc_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.ChatChannel.desc)
}
#if LANG_CXX11
inline void ChatChannel::set_desc(::std::string&& value) {
  
  desc_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.ChatChannel.desc)
}
#endif
inline void ChatChannel::set_desc(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  desc_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.ChatChannel.desc)
}
inline void ChatChannel::set_desc(const char* value, size_t size) {
  
  desc_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.ChatChannel.desc)
}
inline ::std::string* ChatChannel::mutable_desc() {
  
  // @@protoc_insertion_point(field_mutable:dc2.ChatChannel.desc)
  return desc_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChatChannel::release_desc() {
  // @@protoc_insertion_point(field_release:dc2.ChatChannel.desc)
  
  return desc_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChatChannel::set_allocated_desc(::std::string* desc) {
  if (desc != NULL) {
    
  } else {
    
  }
  desc_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), desc);
  // @@protoc_insertion_point(field_set_allocated:dc2.ChatChannel.desc)
}

// bool removed = 4;
inline void ChatChannel::clear_removed() {
  removed_ = false;
}
inline bool ChatChannel::removed() const {
  // @@protoc_insertion_point(field_get:dc2.ChatChannel.removed)
  return removed_;
}
inline void ChatChannel::set_removed(bool value) {
  
  removed_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChatChannel.removed)
}

// bool private = 5;
inline void ChatChannel::clear_private_() {
  private__ = false;
}
inline bool ChatChannel::private_() const {
  // @@protoc_insertion_point(field_get:dc2.ChatChannel.private)
  return private__;
}
inline void ChatChannel::set_private_(bool value) {
  
  private__ = value;
  // @@protoc_insertion_point(field_set:dc2.ChatChannel.private)
}

// -------------------------------------------------------------------

// SetChannelOptionsReq

// int64 sid = 1;
inline void SetChannelOptionsReq::clear_sid() {
  sid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 SetChannelOptionsReq::sid() const {
  // @@protoc_insertion_point(field_get:dc2.SetChannelOptionsReq.sid)
  return sid_;
}
inline void SetChannelOptionsReq::set_sid(::google::protobuf::int64 value) {
  
  sid_ = value;
  // @@protoc_insertion_point(field_set:dc2.SetChannelOptionsReq.sid)
}

// string name = 2;
inline void SetChannelOptionsReq::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& SetChannelOptionsReq::name() const {
  // @@protoc_insertion_point(field_get:dc2.SetChannelOptionsReq.name)
  return name_.GetNoArena();
}
inline void SetChannelOptionsReq::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.SetChannelOptionsReq.name)
}
#if LANG_CXX11
inline void SetChannelOptionsReq::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.SetChannelOptionsReq.name)
}
#endif
inline void SetChannelOptionsReq::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.SetChannelOptionsReq.name)
}
inline void SetChannelOptionsReq::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.SetChannelOptionsReq.name)
}
inline ::std::string* SetChannelOptionsReq::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:dc2.SetChannelOptionsReq.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SetChannelOptionsReq::release_name() {
  // @@protoc_insertion_point(field_release:dc2.SetChannelOptionsReq.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SetChannelOptionsReq::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:dc2.SetChannelOptionsReq.name)
}

// .dc2.SetChannelOptionsReq.State state = 3;
inline void SetChannelOptionsReq::clear_state() {
  state_ = 0;
}
inline ::dc2::SetChannelOptionsReq_State SetChannelOptionsReq::state() const {
  // @@protoc_insertion_point(field_get:dc2.SetChannelOptionsReq.state)
  return static_cast< ::dc2::SetChannelOptionsReq_State >(state_);
}
inline void SetChannelOptionsReq::set_state(::dc2::SetChannelOptionsReq_State value) {
  
  state_ = value;
  // @@protoc_insertion_point(field_set:dc2.SetChannelOptionsReq.state)
}

// -------------------------------------------------------------------

// ChatMessage

// string text = 1;
inline void ChatMessage::clear_text() {
  text_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& ChatMessage::text() const {
  // @@protoc_insertion_point(field_get:dc2.ChatMessage.text)
  return text_.GetNoArena();
}
inline void ChatMessage::set_text(const ::std::string& value) {
  
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.ChatMessage.text)
}
#if LANG_CXX11
inline void ChatMessage::set_text(::std::string&& value) {
  
  text_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.ChatMessage.text)
}
#endif
inline void ChatMessage::set_text(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.ChatMessage.text)
}
inline void ChatMessage::set_text(const char* value, size_t size) {
  
  text_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.ChatMessage.text)
}
inline ::std::string* ChatMessage::mutable_text() {
  
  // @@protoc_insertion_point(field_mutable:dc2.ChatMessage.text)
  return text_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* ChatMessage::release_text() {
  // @@protoc_insertion_point(field_release:dc2.ChatMessage.text)
  
  return text_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void ChatMessage::set_allocated_text(::std::string* text) {
  if (text != NULL) {
    
  } else {
    
  }
  text_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), text);
  // @@protoc_insertion_point(field_set_allocated:dc2.ChatMessage.text)
}

// .dc2.Time ts = 2;
inline bool ChatMessage::has_ts() const {
  return this != internal_default_instance() && ts_ != NULL;
}
inline void ChatMessage::clear_ts() {
  if (GetArenaNoVirtual() == NULL && ts_ != NULL) delete ts_;
  ts_ = NULL;
}
inline const ::dc2::Time& ChatMessage::ts() const {
  const ::dc2::Time* p = ts_;
  // @@protoc_insertion_point(field_get:dc2.ChatMessage.ts)
  return p != NULL ? *p : *reinterpret_cast<const ::dc2::Time*>(
      &::dc2::_Time_default_instance_);
}
inline ::dc2::Time* ChatMessage::mutable_ts() {
  
  if (ts_ == NULL) {
    ts_ = new ::dc2::Time;
  }
  // @@protoc_insertion_point(field_mutable:dc2.ChatMessage.ts)
  return ts_;
}
inline ::dc2::Time* ChatMessage::release_ts() {
  // @@protoc_insertion_point(field_release:dc2.ChatMessage.ts)
  
  ::dc2::Time* temp = ts_;
  ts_ = NULL;
  return temp;
}
inline void ChatMessage::set_allocated_ts(::dc2::Time* ts) {
  delete ts_;
  ts_ = ts;
  if (ts) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:dc2.ChatMessage.ts)
}

// int64 author = 3;
inline void ChatMessage::clear_author() {
  author_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 ChatMessage::author() const {
  // @@protoc_insertion_point(field_get:dc2.ChatMessage.author)
  return author_;
}
inline void ChatMessage::set_author(::google::protobuf::int64 value) {
  
  author_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChatMessage.author)
}

// int64 channel = 4;
inline bool ChatMessage::has_channel() const {
  return destitation_case() == kChannel;
}
inline void ChatMessage::set_has_channel() {
  _oneof_case_[0] = kChannel;
}
inline void ChatMessage::clear_channel() {
  if (has_channel()) {
    destitation_.channel_ = GOOGLE_LONGLONG(0);
    clear_has_destitation();
  }
}
inline ::google::protobuf::int64 ChatMessage::channel() const {
  // @@protoc_insertion_point(field_get:dc2.ChatMessage.channel)
  if (has_channel()) {
    return destitation_.channel_;
  }
  return GOOGLE_LONGLONG(0);
}
inline void ChatMessage::set_channel(::google::protobuf::int64 value) {
  if (!has_channel()) {
    clear_destitation();
    set_has_channel();
  }
  destitation_.channel_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChatMessage.channel)
}

// int64 pm_user = 5;
inline bool ChatMessage::has_pm_user() const {
  return destitation_case() == kPmUser;
}
inline void ChatMessage::set_has_pm_user() {
  _oneof_case_[0] = kPmUser;
}
inline void ChatMessage::clear_pm_user() {
  if (has_pm_user()) {
    destitation_.pm_user_ = GOOGLE_LONGLONG(0);
    clear_has_destitation();
  }
}
inline ::google::protobuf::int64 ChatMessage::pm_user() const {
  // @@protoc_insertion_point(field_get:dc2.ChatMessage.pm_user)
  if (has_pm_user()) {
    return destitation_.pm_user_;
  }
  return GOOGLE_LONGLONG(0);
}
inline void ChatMessage::set_pm_user(::google::protobuf::int64 value) {
  if (!has_pm_user()) {
    clear_destitation();
    set_has_pm_user();
  }
  destitation_.pm_user_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChatMessage.pm_user)
}

// bool me = 6;
inline void ChatMessage::clear_me() {
  me_ = false;
}
inline bool ChatMessage::me() const {
  // @@protoc_insertion_point(field_get:dc2.ChatMessage.me)
  return me_;
}
inline void ChatMessage::set_me(bool value) {
  
  me_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChatMessage.me)
}

// bool notify = 7;
inline void ChatMessage::clear_notify() {
  notify_ = false;
}
inline bool ChatMessage::notify() const {
  // @@protoc_insertion_point(field_get:dc2.ChatMessage.notify)
  return notify_;
}
inline void ChatMessage::set_notify(bool value) {
  
  notify_ = value;
  // @@protoc_insertion_point(field_set:dc2.ChatMessage.notify)
}

// repeated int64 mention = 8;
inline int ChatMessage::mention_size() const {
  return mention_.size();
}
inline void ChatMessage::clear_mention() {
  mention_.Clear();
}
inline ::google::protobuf::int64 ChatMessage::mention(int index) const {
  // @@protoc_insertion_point(field_get:dc2.ChatMessage.mention)
  return mention_.Get(index);
}
inline void ChatMessage::set_mention(int index, ::google::protobuf::int64 value) {
  mention_.Set(index, value);
  // @@protoc_insertion_point(field_set:dc2.ChatMessage.mention)
}
inline void ChatMessage::add_mention(::google::protobuf::int64 value) {
  mention_.Add(value);
  // @@protoc_insertion_point(field_add:dc2.ChatMessage.mention)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
ChatMessage::mention() const {
  // @@protoc_insertion_point(field_list:dc2.ChatMessage.mention)
  return mention_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
ChatMessage::mutable_mention() {
  // @@protoc_insertion_point(field_mutable_list:dc2.ChatMessage.mention)
  return &mention_;
}

inline bool ChatMessage::has_destitation() const {
  return destitation_case() != DESTITATION_NOT_SET;
}
inline void ChatMessage::clear_has_destitation() {
  _oneof_case_[0] = DESTITATION_NOT_SET;
}
inline ChatMessage::DestitationCase ChatMessage::destitation_case() const {
  return ChatMessage::DestitationCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// Version

// int32 major = 1;
inline void Version::clear_major() {
  major_ = 0;
}
inline ::google::protobuf::int32 Version::major() const {
  // @@protoc_insertion_point(field_get:dc2.Version.major)
  return major_;
}
inline void Version::set_major(::google::protobuf::int32 value) {
  
  major_ = value;
  // @@protoc_insertion_point(field_set:dc2.Version.major)
}

// int32 minor = 2;
inline void Version::clear_minor() {
  minor_ = 0;
}
inline ::google::protobuf::int32 Version::minor() const {
  // @@protoc_insertion_point(field_get:dc2.Version.minor)
  return minor_;
}
inline void Version::set_minor(::google::protobuf::int32 value) {
  
  minor_ = value;
  // @@protoc_insertion_point(field_set:dc2.Version.minor)
}

// int32 patch = 3;
inline void Version::clear_patch() {
  patch_ = 0;
}
inline ::google::protobuf::int32 Version::patch() const {
  // @@protoc_insertion_point(field_get:dc2.Version.patch)
  return patch_;
}
inline void Version::set_patch(::google::protobuf::int32 value) {
  
  patch_ = value;
  // @@protoc_insertion_point(field_set:dc2.Version.patch)
}

// -------------------------------------------------------------------

// SoftwareInfo

// string name = 1;
inline void SoftwareInfo::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& SoftwareInfo::name() const {
  // @@protoc_insertion_point(field_get:dc2.SoftwareInfo.name)
  return name_.GetNoArena();
}
inline void SoftwareInfo::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.SoftwareInfo.name)
}
#if LANG_CXX11
inline void SoftwareInfo::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.SoftwareInfo.name)
}
#endif
inline void SoftwareInfo::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.SoftwareInfo.name)
}
inline void SoftwareInfo::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.SoftwareInfo.name)
}
inline ::std::string* SoftwareInfo::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:dc2.SoftwareInfo.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* SoftwareInfo::release_name() {
  // @@protoc_insertion_point(field_release:dc2.SoftwareInfo.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void SoftwareInfo::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:dc2.SoftwareInfo.name)
}

// .dc2.Version version = 2;
inline bool SoftwareInfo::has_version() const {
  return this != internal_default_instance() && version_ != NULL;
}
inline void SoftwareInfo::clear_version() {
  if (GetArenaNoVirtual() == NULL && version_ != NULL) delete version_;
  version_ = NULL;
}
inline const ::dc2::Version& SoftwareInfo::version() const {
  const ::dc2::Version* p = version_;
  // @@protoc_insertion_point(field_get:dc2.SoftwareInfo.version)
  return p != NULL ? *p : *reinterpret_cast<const ::dc2::Version*>(
      &::dc2::_Version_default_instance_);
}
inline ::dc2::Version* SoftwareInfo::mutable_version() {
  
  if (version_ == NULL) {
    version_ = new ::dc2::Version;
  }
  // @@protoc_insertion_point(field_mutable:dc2.SoftwareInfo.version)
  return version_;
}
inline ::dc2::Version* SoftwareInfo::release_version() {
  // @@protoc_insertion_point(field_release:dc2.SoftwareInfo.version)
  
  ::dc2::Version* temp = version_;
  version_ = NULL;
  return temp;
}
inline void SoftwareInfo::set_allocated_version(::dc2::Version* version) {
  delete version_;
  version_ = version;
  if (version) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:dc2.SoftwareInfo.version)
}

// -------------------------------------------------------------------

// UserDetails

// string real_name = 1;
inline void UserDetails::clear_real_name() {
  real_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& UserDetails::real_name() const {
  // @@protoc_insertion_point(field_get:dc2.UserDetails.real_name)
  return real_name_.GetNoArena();
}
inline void UserDetails::set_real_name(const ::std::string& value) {
  
  real_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.UserDetails.real_name)
}
#if LANG_CXX11
inline void UserDetails::set_real_name(::std::string&& value) {
  
  real_name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.UserDetails.real_name)
}
#endif
inline void UserDetails::set_real_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  real_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.UserDetails.real_name)
}
inline void UserDetails::set_real_name(const char* value, size_t size) {
  
  real_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.UserDetails.real_name)
}
inline ::std::string* UserDetails::mutable_real_name() {
  
  // @@protoc_insertion_point(field_mutable:dc2.UserDetails.real_name)
  return real_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* UserDetails::release_real_name() {
  // @@protoc_insertion_point(field_release:dc2.UserDetails.real_name)
  
  return real_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void UserDetails::set_allocated_real_name(::std::string* real_name) {
  if (real_name != NULL) {
    
  } else {
    
  }
  real_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), real_name);
  // @@protoc_insertion_point(field_set_allocated:dc2.UserDetails.real_name)
}

// string about = 2;
inline void UserDetails::clear_about() {
  about_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& UserDetails::about() const {
  // @@protoc_insertion_point(field_get:dc2.UserDetails.about)
  return about_.GetNoArena();
}
inline void UserDetails::set_about(const ::std::string& value) {
  
  about_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.UserDetails.about)
}
#if LANG_CXX11
inline void UserDetails::set_about(::std::string&& value) {
  
  about_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.UserDetails.about)
}
#endif
inline void UserDetails::set_about(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  about_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.UserDetails.about)
}
inline void UserDetails::set_about(const char* value, size_t size) {
  
  about_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.UserDetails.about)
}
inline ::std::string* UserDetails::mutable_about() {
  
  // @@protoc_insertion_point(field_mutable:dc2.UserDetails.about)
  return about_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* UserDetails::release_about() {
  // @@protoc_insertion_point(field_release:dc2.UserDetails.about)
  
  return about_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void UserDetails::set_allocated_about(::std::string* about) {
  if (about != NULL) {
    
  } else {
    
  }
  about_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), about);
  // @@protoc_insertion_point(field_set_allocated:dc2.UserDetails.about)
}

// string email = 3;
inline void UserDetails::clear_email() {
  email_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& UserDetails::email() const {
  // @@protoc_insertion_point(field_get:dc2.UserDetails.email)
  return email_.GetNoArena();
}
inline void UserDetails::set_email(const ::std::string& value) {
  
  email_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.UserDetails.email)
}
#if LANG_CXX11
inline void UserDetails::set_email(::std::string&& value) {
  
  email_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.UserDetails.email)
}
#endif
inline void UserDetails::set_email(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  email_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.UserDetails.email)
}
inline void UserDetails::set_email(const char* value, size_t size) {
  
  email_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.UserDetails.email)
}
inline ::std::string* UserDetails::mutable_email() {
  
  // @@protoc_insertion_point(field_mutable:dc2.UserDetails.email)
  return email_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* UserDetails::release_email() {
  // @@protoc_insertion_point(field_release:dc2.UserDetails.email)
  
  return email_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void UserDetails::set_allocated_email(::std::string* email) {
  if (email != NULL) {
    
  } else {
    
  }
  email_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), email);
  // @@protoc_insertion_point(field_set_allocated:dc2.UserDetails.email)
}

// -------------------------------------------------------------------

// User

// int64 sid = 1;
inline void User::clear_sid() {
  sid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 User::sid() const {
  // @@protoc_insertion_point(field_get:dc2.User.sid)
  return sid_;
}
inline void User::set_sid(::google::protobuf::int64 value) {
  
  sid_ = value;
  // @@protoc_insertion_point(field_set:dc2.User.sid)
}

// string name = 2;
inline void User::clear_name() {
  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline const ::std::string& User::name() const {
  // @@protoc_insertion_point(field_get:dc2.User.name)
  return name_.GetNoArena();
}
inline void User::set_name(const ::std::string& value) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
  // @@protoc_insertion_point(field_set:dc2.User.name)
}
#if LANG_CXX11
inline void User::set_name(::std::string&& value) {
  
  name_.SetNoArena(
    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:dc2.User.name)
}
#endif
inline void User::set_name(const char* value) {
  GOOGLE_DCHECK(value != NULL);
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:dc2.User.name)
}
inline void User::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:dc2.User.name)
}
inline ::std::string* User::mutable_name() {
  
  // @@protoc_insertion_point(field_mutable:dc2.User.name)
  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline ::std::string* User::release_name() {
  // @@protoc_insertion_point(field_release:dc2.User.name)
  
  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
}
inline void User::set_allocated_name(::std::string* name) {
  if (name != NULL) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:dc2.User.name)
}

// .dc2.User.Kind kind = 3;
inline void User::clear_kind() {
  kind_ = 0;
}
inline ::dc2::User_Kind User::kind() const {
  // @@protoc_insertion_point(field_get:dc2.User.kind)
  return static_cast< ::dc2::User_Kind >(kind_);
}
inline void User::set_kind(::dc2::User_Kind value) {
  
  kind_ = value;
  // @@protoc_insertion_point(field_set:dc2.User.kind)
}

// .dc2.User.Status status = 4;
inline void User::clear_status() {
  status_ = 0;
}
inline ::dc2::User_Status User::status() const {
  // @@protoc_insertion_point(field_get:dc2.User.status)
  return static_cast< ::dc2::User_Status >(status_);
}
inline void User::set_status(::dc2::User_Status value) {
  
  status_ = value;
  // @@protoc_insertion_point(field_set:dc2.User.status)
}

// .dc2.User.Role role = 5;
inline void User::clear_role() {
  role_ = 0;
}
inline ::dc2::User_Role User::role() const {
  // @@protoc_insertion_point(field_get:dc2.User.role)
  return static_cast< ::dc2::User_Role >(role_);
}
inline void User::set_role(::dc2::User_Role value) {
  
  role_ = value;
  // @@protoc_insertion_point(field_set:dc2.User.role)
}

// .dc2.SoftwareInfo client = 6;
inline bool User::has_client() const {
  return this != internal_default_instance() && client_ != NULL;
}
inline void User::clear_client() {
  if (GetArenaNoVirtual() == NULL && client_ != NULL) delete client_;
  client_ = NULL;
}
inline const ::dc2::SoftwareInfo& User::client() const {
  const ::dc2::SoftwareInfo* p = client_;
  // @@protoc_insertion_point(field_get:dc2.User.client)
  return p != NULL ? *p : *reinterpret_cast<const ::dc2::SoftwareInfo*>(
      &::dc2::_SoftwareInfo_default_instance_);
}
inline ::dc2::SoftwareInfo* User::mutable_client() {
  
  if (client_ == NULL) {
    client_ = new ::dc2::SoftwareInfo;
  }
  // @@protoc_insertion_point(field_mutable:dc2.User.client)
  return client_;
}
inline ::dc2::SoftwareInfo* User::release_client() {
  // @@protoc_insertion_point(field_release:dc2.User.client)
  
  ::dc2::SoftwareInfo* temp = client_;
  client_ = NULL;
  return temp;
}
inline void User::set_allocated_client(::dc2::SoftwareInfo* client) {
  delete client_;
  client_ = client;
  if (client) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:dc2.User.client)
}

// .dc2.UserDetails details = 7;
inline bool User::has_details() const {
  return this != internal_default_instance() && details_ != NULL;
}
inline void User::clear_details() {
  if (GetArenaNoVirtual() == NULL && details_ != NULL) delete details_;
  details_ = NULL;
}
inline const ::dc2::UserDetails& User::details() const {
  const ::dc2::UserDetails* p = details_;
  // @@protoc_insertion_point(field_get:dc2.User.details)
  return p != NULL ? *p : *reinterpret_cast<const ::dc2::UserDetails*>(
      &::dc2::_UserDetails_default_instance_);
}
inline ::dc2::UserDetails* User::mutable_details() {
  
  if (details_ == NULL) {
    details_ = new ::dc2::UserDetails;
  }
  // @@protoc_insertion_point(field_mutable:dc2.User.details)
  return details_;
}
inline ::dc2::UserDetails* User::release_details() {
  // @@protoc_insertion_point(field_release:dc2.User.details)
  
  ::dc2::UserDetails* temp = details_;
  details_ = NULL;
  return temp;
}
inline void User::set_allocated_details(::dc2::UserDetails* details) {
  delete details_;
  details_ = details;
  if (details) {
    
  } else {
    
  }
  // @@protoc_insertion_point(field_set_allocated:dc2.User.details)
}

// -------------------------------------------------------------------

// UsersReq

// int64 channel = 1;
inline void UsersReq::clear_channel() {
  channel_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 UsersReq::channel() const {
  // @@protoc_insertion_point(field_get:dc2.UsersReq.channel)
  return channel_;
}
inline void UsersReq::set_channel(::google::protobuf::int64 value) {
  
  channel_ = value;
  // @@protoc_insertion_point(field_set:dc2.UsersReq.channel)
}

// int64 after_sid = 2;
inline void UsersReq::clear_after_sid() {
  after_sid_ = GOOGLE_LONGLONG(0);
}
inline ::google::protobuf::int64 UsersReq::after_sid() const {
  // @@protoc_insertion_point(field_get:dc2.UsersReq.after_sid)
  return after_sid_;
}
inline void UsersReq::set_after_sid(::google::protobuf::int64 value) {
  
  after_sid_ = value;
  // @@protoc_insertion_point(field_set:dc2.UsersReq.after_sid)
}

// int32 limit = 3;
inline void UsersReq::clear_limit() {
  limit_ = 0;
}
inline ::google::protobuf::int32 UsersReq::limit() const {
  // @@protoc_insertion_point(field_get:dc2.UsersReq.limit)
  return limit_;
}
inline void UsersReq::set_limit(::google::protobuf::int32 value) {
  
  limit_ = value;
  // @@protoc_insertion_point(field_set:dc2.UsersReq.limit)
}

// bool watch = 4;
inline void UsersReq::clear_watch() {
  watch_ = false;
}
inline bool UsersReq::watch() const {
  // @@protoc_insertion_point(field_get:dc2.UsersReq.watch)
  return watch_;
}
inline void UsersReq::set_watch(bool value) {
  
  watch_ = value;
  // @@protoc_insertion_point(field_set:dc2.UsersReq.watch)
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
#endif  // !PROTOBUF_INLINE_NOT_IN_HEADERS
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)


}  // namespace dc2

namespace google {
namespace protobuf {

template <> struct is_proto_enum< ::dc2::SetChannelOptionsReq_State> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dc2::SetChannelOptionsReq_State>() {
  return ::dc2::SetChannelOptionsReq_State_descriptor();
}
template <> struct is_proto_enum< ::dc2::User_Kind> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dc2::User_Kind>() {
  return ::dc2::User_Kind_descriptor();
}
template <> struct is_proto_enum< ::dc2::User_Status> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dc2::User_Status>() {
  return ::dc2::User_Status_descriptor();
}
template <> struct is_proto_enum< ::dc2::User_Role> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::dc2::User_Role>() {
  return ::dc2::User_Role_descriptor();
}

}  // namespace protobuf
}  // namespace google

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_dc2_2eproto__INCLUDED
